package Lambda;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Consumer;

/**
 * @author : <h2>冷环渊</h2>
 * @date : 2021/12/10
 * @context: <h4>
 * 1. 举例子（o1,o2）-> Integeer.compare(o1,o2)
 * 2.格式：
 * -> Lambda操作符 或者叫箭头操作符
 * ()形参列表 相当于是接口中的抽象方法的参数列表，可以省去类型
 * ->右边 Lambda体 其实就是重写抽象对象的方法体
 * 3.Lambda 表达式的使用（有六种情况可以介绍）
 * 4.本质 Lambda 表达式的本质：作为接口的实例
 * </h4>
 */
public class LambdaTest1 {
    /**
     * @return :  * @return : null
     * @author : <h2>冷环渊</h2>
     * @date : 2021/12/10
     * @context: <h3>语法格式一 ：没有参数 没有返回值 </h3>
     * @params :  null
     */
    @Test
    public void Test1() {
        // 传统 的 创建一个 线程 打印
        Runnable r1 = new Runnable() {

            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();

        System.out.println("****************************");


        // 用 lambda 表达式 的方法
        Runnable r2 = () -> System.out.println("我爱看北京天安门");
        r2.run();
    }

    /**
     * @return :  * @return : null
     * @author : <h2>冷环渊</h2>
     * @date : 2021/12/10
     * @context: <h3> 语法表达式二 Lambda 需要一个参数 但是没有返回值 </h3>
     * @params :  null
     */
    @Test
    public void test2() {
        //传统的区别
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别");
        System.out.println("**************************");
        //使用lambda
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("给你一拳，再给你一拳");
    }

    /**
     * @return :  * @return : null
     * @author : <h2>冷环渊</h2>
     * @date : 2021/12/10
     * @context: <h3>语法格式三：数据类型可以省略，因为可以用编译器推算的出，称为 ：”类型推断“ </h3>
     * @params :  null
     */
    @Test
    public void Test3() {
        //使用lambda 还可以再次简化
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("给你一拳，再给你一拳");

        //类型也可以省去
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("我闪避，闪避 miss");
    }

    /**
     * @return :  * @return : null
     * @author : <h2>冷环渊</h2>
     * @date : 2021/12/10
     * @context: <h3> 类型推断的例子</h3>
     * @params :  null
     */
    @Test
    public void Test4() {
        List<String> list = new ArrayList<>();
        int[] arrpub = {
                1, 2, 3
        };
    }

    /**
     * @return :  * @return : null
     * @author : <h2>冷环渊</h2>
     * @date : 2021/12/10
     * @context: <h3>语法格式四：Lambda 只需要一个参数的时候，参数的小括号也可以省去</h3>
     * @params :  null
     */
    @Test
    public void Test5() {
        //类型也可以省去
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("我闪避，闪避 miss");
        //参数只有一个小括号也可以省去
        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("我闪避，闪避 miss");
    }

    /**
     * @return :  * @return : null
     * @author : <h2>冷环渊</h2>
     * @date : 2021/12/10
     * @context: <h3>语法格式五 Lambda 需要两个以上的参数，多条执行语句，且可以有返回值 </h3>
     * @params :  null
     */
    @Test
    public void Test6() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(02);
            }
        };
        System.out.println(com1.compare(12, 21));
        System.out.println(" ***************");
        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(02);
        };
        System.out.println(com2.compare(12, 21));
    }


    /**
     * @return :  * @return : null
     * @author : <h2>冷环渊</h2>
     * @date : 2021/12/11
     * @context: <h3>语法格式六：当Lambda体 只有一条语句的时候，return 与大括号若有都可以忽略 </h3>
     * @params :  null
     */
    @Test
    public void Test7() {
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12, 6));
        System.out.println("*********************");
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12, 21));
    }

    @Test
    public void Test8() {
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("想你的夜~~~~~~~~~");
        System.out.println("********************");
        Consumer<String> con2 = s -> System.out.println(s);
        con2.accept("我给你一拳");
    }
}
